Шпаргалка по операциям контейнерных типов

Что такое контейнеры?

Контейнеры (коллекции, структуры данных) — это типы Python, способные содержать несколько объектов. Вместо трёх переменных name1, name2, name3 — создаёте один контейнер и работаете со всеми тремя скопом.

Основные контейнерные типы

# Список (list) - изменяемый, упорядоченный
my_list = [1, 2, 3, 'текст', 3.14]

# Кортеж (tuple) - неизменяемый, упорядоченный
my_tuple = (1, 2, 3, 'текст')

# Словарь (dict) - пары ключ-значение, изменяемый
my_dict = {'имя': 'Иван', 'возраст': 30, 'город': 'Москва'}

# Множество (set) - уникальные элементы, неупорядоченный
my_set = {1, 2, 3, 3, 2}  # {1, 2, 3} - дубликаты удалены

# Неизменяемое множество (frozenset)
my_frozenset = frozenset([1, 2, 3])

Операции со списками

lst = [1, 2, 3, 4, 5]

# Доступ по индексу
print(lst[0])           # 1 (первый элемент)
print(lst[-1])          # 5 (последний элемент)

# Срезы (slicing)
print(lst[1:4])         # [2, 3, 4]
print(lst[:3])          # [1, 2, 3]
print(lst[2:])          # [3, 4, 5]
print(lst[::2])         # [1, 3, 5] (каждый второй)
print(lst[::-1])        # [5, 4, 3, 2, 1] (в обратном порядке)

# Добавление и удаление
lst.append(6)           # [1, 2, 3, 4, 5, 6]
lst.extend([7, 8])      # [1, 2, 3, 4, 5, 6, 7, 8]
lst.insert(0, 0)        # [0, 1, 2, 3, 4, 5, 6, 7, 8]
lst.remove(3)           # Удаляет первое вхождение 3
removed = lst.pop()     # Удаляет последний и возвращает его

# Поиск
print(lst.index(2))     # Индекс элемента 2
print(lst.count(2))     # Сколько раз 2 встречается

# Сортировка
lst.sort()              # Сортирует на месте
sorted_lst = sorted(lst) # Возвращает новый отсортированный список

Операции с кортежами

tpl = (1, 2, 3, 'текст', 3.14)

# Те же операции доступа как в списках
print(tpl[0])           # 1
print(tpl[1:3])         # (2, 3)
print(tpl[-1])          # 3.14

# Но нельзя изменять!
# tpl[0] = 10           # TypeError!

# Полезные операции
print(len(tpl))         # 5
print(2 in tpl)         # True
print(tpl.count(3))     # 1
print(tpl.index(2))     # 1

# Распаковка
a, b, c, d, e = tpl
print(a)                # 1
print(b)                # 2

# Неполная распаковка
first, *middle, last = tpl
print(first)            # 1
print(middle)           # [2, 3, 'текст', 3.14]
print(last)             # 3.14

Операции со словарями

d = {'имя': 'Иван', 'возраст': 30, 'город': 'Москва'}

# Доступ и установка
print(d['имя'])         # Иван
d['профессия'] = 'инженер'  # Добавит новый ключ

# Безопасный доступ
print(d.get('имя'))     # Иван
print(d.get('телефон', 'не указан'))  # не указан

# Проверка наличия ключа
if 'возраст' in d:
    print(d['возраст'])

# Итерация
for ключ in d:
    print(f"{ключ}: {d[ключ]}")

# Методы
d.keys()                # dict_keys(['имя', 'возраст', ...])
d.values()              # dict_values(['Иван', 30, ...])
d.items()               # dict_items([('имя', 'Иван'), ...])

# Удаление
del d['город']          # Удаляет 'город'
removed_val = d.pop('профессия')  # Удаляет и возвращает

# Слияние (Python 3.9+)
d2 = {'язык': 'Python'}
d_merged = d | d2       # Объединённый словарь

Операции со множествами

s = {1, 2, 3, 4, 5}
s2 = {4, 5, 6, 7}

# Добавление и удаление
s.add(10)               # Добавляет 10
s.remove(3)             # Удаляет 3 (ошибка если нет)
s.discard(99)           # Удаляет 99 (нет ошибки если нет)

# Операции множеств
print(s | s2)           # Объединение {1, 2, 3, 4, 5, 6, 7}
print(s & s2)           # Пересечение {4, 5}
print(s - s2)           # Разность {1, 2, 3}
print(s ^ s2)           # Симметричная разность {1, 2, 3, 6, 7}

# Проверки
print(s2.issubset(s))   # Подмножество ли s2?
print(s.issuperset(s2)) # Надмножество ли s?

# Удаление дубликатов
lst = [1, 2, 2, 3, 3, 3, 4]
unique = set(lst)       # {1, 2, 3, 4}

Диаграмма типов и их свойств

graph TD
    A["Контейнерные типы"]
    A --> B["Упорядоченные"]
    A --> C["Неупорядоченные"]

    B --> D["List<br/>Изменяемый"]
    B --> E["Tuple<br/>Неизменяемый"]

    C --> F["Dict<br/>Пары K-V<br/>Изменяемый"]
    C --> G["Set<br/>Уникальные<br/>Изменяемый"]
    C --> H["FrozenSet<br/>Уникальные<br/>Неизменяемый"]

Сравнение производительности

import time

# Список vs Кортеж: создание
start = time.time()
lst = [i for i in range(1000000)]
print(f"List: {time.time() - start:.4f}s")

start = time.time()
tpl = tuple(range(1000000))
print(f"Tuple: {time.time() - start:.4f}s")

# Поиск элемента: список vs множество
start = time.time()
lst = list(range(100000))
99999 in lst
print(f"List search: {time.time() - start:.6f}s")

start = time.time()
s = set(range(100000))
99999 in s
print(f"Set search: {time.time() - start:.6f}s")

Лучшие практики

Используйте список для изменяемых коллекций
Используйте кортеж для неизменяемых данных и ключей dict
Используйте словарь для поиска по ключу
Используйте множество для проверки вхождения и уникальности
Выбирайте тип в зависимости от задачи, а не наоборот
Помните о производительности: множества намного быстрее для поиска
Документируйте структуру сложных контейнеров